{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.6.7 | packaged by conda-forge | (default, Jul  2 2019, 02:18:42) \n",
      "[GCC 7.3.0]\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "print(sys.version)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sys.float_info"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['A', 'B', 'C', 'D']"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'A,B,C,D'.split(',')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 2}"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{'a':1, 'a':2}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 red\n",
      "1 yellow\n",
      "2 green\n",
      "3 purple\n",
      "4 blue\n"
     ]
    }
   ],
   "source": [
    "# Loop through the list and iterate on both index and element value\n",
    "\n",
    "squares=['red', 'yellow', 'green', 'purple', 'blue']\n",
    "\n",
    "for i, square in enumerate(squares):\n",
    "    print(i, square)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[0;31mDocstring:\u001b[0m\n",
       "dot(a, b, out=None)\n",
       "\n",
       "Dot product of two arrays. Specifically,\n",
       "\n",
       "- If both `a` and `b` are 1-D arrays, it is inner product of vectors\n",
       "  (without complex conjugation).\n",
       "\n",
       "- If both `a` and `b` are 2-D arrays, it is matrix multiplication,\n",
       "  but using :func:`matmul` or ``a @ b`` is preferred.\n",
       "\n",
       "- If either `a` or `b` is 0-D (scalar), it is equivalent to :func:`multiply`\n",
       "  and using ``numpy.multiply(a, b)`` or ``a * b`` is preferred.\n",
       "\n",
       "- If `a` is an N-D array and `b` is a 1-D array, it is a sum product over\n",
       "  the last axis of `a` and `b`.\n",
       "\n",
       "- If `a` is an N-D array and `b` is an M-D array (where ``M>=2``), it is a\n",
       "  sum product over the last axis of `a` and the second-to-last axis of `b`::\n",
       "\n",
       "    dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])\n",
       "\n",
       "Parameters\n",
       "----------\n",
       "a : array_like\n",
       "    First argument.\n",
       "b : array_like\n",
       "    Second argument.\n",
       "out : ndarray, optional\n",
       "    Output argument. This must have the exact kind that would be returned\n",
       "    if it was not used. In particular, it must have the right type, must be\n",
       "    C-contiguous, and its dtype must be the dtype that would be returned\n",
       "    for `dot(a,b)`. This is a performance feature. Therefore, if these\n",
       "    conditions are not met, an exception is raised, instead of attempting\n",
       "    to be flexible.\n",
       "\n",
       "Returns\n",
       "-------\n",
       "output : ndarray\n",
       "    Returns the dot product of `a` and `b`.  If `a` and `b` are both\n",
       "    scalars or both 1-D arrays then a scalar is returned; otherwise\n",
       "    an array is returned.\n",
       "    If `out` is given, then it is returned.\n",
       "\n",
       "Raises\n",
       "------\n",
       "ValueError\n",
       "    If the last dimension of `a` is not the same size as\n",
       "    the second-to-last dimension of `b`.\n",
       "\n",
       "See Also\n",
       "--------\n",
       "vdot : Complex-conjugating dot product.\n",
       "tensordot : Sum products over arbitrary axes.\n",
       "einsum : Einstein summation convention.\n",
       "matmul : '@' operator as method with out parameter.\n",
       "\n",
       "Examples\n",
       "--------\n",
       ">>> np.dot(3, 4)\n",
       "12\n",
       "\n",
       "Neither argument is complex-conjugated:\n",
       "\n",
       ">>> np.dot([2j, 3j], [2j, 3j])\n",
       "(-13+0j)\n",
       "\n",
       "For 2-D arrays it is the matrix product:\n",
       "\n",
       ">>> a = [[1, 0], [0, 1]]\n",
       ">>> b = [[4, 1], [2, 2]]\n",
       ">>> np.dot(a, b)\n",
       "array([[4, 1],\n",
       "       [2, 2]])\n",
       "\n",
       ">>> a = np.arange(3*4*5*6).reshape((3,4,5,6))\n",
       ">>> b = np.arange(3*4*5*6)[::-1].reshape((5,4,6,3))\n",
       ">>> np.dot(a, b)[2,3,2,1,2,2]\n",
       "499128\n",
       ">>> sum(a[2,3,2,:] * b[1,2,:,2])\n",
       "499128\n",
       "\u001b[0;31mType:\u001b[0m      builtin_function_or_method\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "np.dot?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[0;31mType:\u001b[0m        module\n",
       "\u001b[0;31mString form:\u001b[0m <module 'numpy' from '/home/jupyterlab/conda/envs/python/lib/python3.6/site-packages/numpy/__init__.py'>\n",
       "\u001b[0;31mFile:\u001b[0m        ~/conda/envs/python/lib/python3.6/site-packages/numpy/__init__.py\n",
       "\u001b[0;31mDocstring:\u001b[0m  \n",
       "NumPy\n",
       "=====\n",
       "\n",
       "Provides\n",
       "  1. An array object of arbitrary homogeneous items\n",
       "  2. Fast mathematical operations over arrays\n",
       "  3. Linear Algebra, Fourier Transforms, Random Number Generation\n",
       "\n",
       "How to use the documentation\n",
       "----------------------------\n",
       "Documentation is available in two forms: docstrings provided\n",
       "with the code, and a loose standing reference guide, available from\n",
       "`the NumPy homepage <http://www.scipy.org>`_.\n",
       "\n",
       "We recommend exploring the docstrings using\n",
       "`IPython <http://ipython.scipy.org>`_, an advanced Python shell with\n",
       "TAB-completion and introspection capabilities.  See below for further\n",
       "instructions.\n",
       "\n",
       "The docstring examples assume that `numpy` has been imported as `np`::\n",
       "\n",
       "  >>> import numpy as np\n",
       "\n",
       "Code snippets are indicated by three greater-than signs::\n",
       "\n",
       "  >>> x = 42\n",
       "  >>> x = x + 1\n",
       "\n",
       "Use the built-in ``help`` function to view a function's docstring::\n",
       "\n",
       "  >>> help(np.sort)\n",
       "  ... # doctest: +SKIP\n",
       "\n",
       "For some objects, ``np.info(obj)`` may provide additional help.  This is\n",
       "particularly true if you see the line \"Help on ufunc object:\" at the top\n",
       "of the help() page.  Ufuncs are implemented in C, not Python, for speed.\n",
       "The native Python help() does not know how to view their help, but our\n",
       "np.info() function does.\n",
       "\n",
       "To search for documents containing a keyword, do::\n",
       "\n",
       "  >>> np.lookfor('keyword')\n",
       "  ... # doctest: +SKIP\n",
       "\n",
       "General-purpose documents like a glossary and help on the basic concepts\n",
       "of numpy are available under the ``doc`` sub-module::\n",
       "\n",
       "  >>> from numpy import doc\n",
       "  >>> help(doc)\n",
       "  ... # doctest: +SKIP\n",
       "\n",
       "Available subpackages\n",
       "---------------------\n",
       "doc\n",
       "    Topical documentation on broadcasting, indexing, etc.\n",
       "lib\n",
       "    Basic functions used by several sub-packages.\n",
       "random\n",
       "    Core Random Tools\n",
       "linalg\n",
       "    Core Linear Algebra Tools\n",
       "fft\n",
       "    Core FFT routines\n",
       "polynomial\n",
       "    Polynomial tools\n",
       "testing\n",
       "    NumPy testing tools\n",
       "f2py\n",
       "    Fortran to Python Interface Generator.\n",
       "distutils\n",
       "    Enhancements to distutils with support for\n",
       "    Fortran compilers support and more.\n",
       "\n",
       "Utilities\n",
       "---------\n",
       "test\n",
       "    Run numpy unittests\n",
       "show_config\n",
       "    Show numpy build configuration\n",
       "dual\n",
       "    Overwrite certain functions with high-performance Scipy tools\n",
       "matlib\n",
       "    Make everything matrices.\n",
       "__version__\n",
       "    NumPy version string\n",
       "\n",
       "Viewing documentation using IPython\n",
       "-----------------------------------\n",
       "Start IPython with the NumPy profile (``ipython -p numpy``), which will\n",
       "import `numpy` under the alias `np`.  Then, use the ``cpaste`` command to\n",
       "paste examples into the shell.  To see which functions are available in\n",
       "`numpy`, type ``np.<TAB>`` (where ``<TAB>`` refers to the TAB key), or use\n",
       "``np.*cos*?<ENTER>`` (where ``<ENTER>`` refers to the ENTER key) to narrow\n",
       "down the list.  To view the docstring for a function, use\n",
       "``np.cos?<ENTER>`` (to view the docstring) and ``np.cos??<ENTER>`` (to view\n",
       "the source code).\n",
       "\n",
       "Copies vs. in-place operation\n",
       "-----------------------------\n",
       "Most of the functions in `numpy` return a copy of the array argument\n",
       "(e.g., `np.sort`).  In-place versions of these functions are often\n",
       "available as array methods, i.e. ``x = np.array([1,2,3]); x.sort()``.\n",
       "Exceptions to this rule are documented.\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "np?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[0;31mType:\u001b[0m        module\n",
       "\u001b[0;31mString form:\u001b[0m <module 'pandas' from '/home/jupyterlab/conda/envs/python/lib/python3.6/site-packages/pandas/__init__.py'>\n",
       "\u001b[0;31mFile:\u001b[0m        ~/conda/envs/python/lib/python3.6/site-packages/pandas/__init__.py\n",
       "\u001b[0;31mDocstring:\u001b[0m  \n",
       "pandas - a powerful data analysis and manipulation library for Python\n",
       "=====================================================================\n",
       "\n",
       "**pandas** is a Python package providing fast, flexible, and expressive data\n",
       "structures designed to make working with \"relational\" or \"labeled\" data both\n",
       "easy and intuitive. It aims to be the fundamental high-level building block for\n",
       "doing practical, **real world** data analysis in Python. Additionally, it has\n",
       "the broader goal of becoming **the most powerful and flexible open source data\n",
       "analysis / manipulation tool available in any language**. It is already well on\n",
       "its way toward this goal.\n",
       "\n",
       "Main Features\n",
       "-------------\n",
       "Here are just a few of the things that pandas does well:\n",
       "\n",
       "  - Easy handling of missing data in floating point as well as non-floating\n",
       "    point data.\n",
       "  - Size mutability: columns can be inserted and deleted from DataFrame and\n",
       "    higher dimensional objects\n",
       "  - Automatic and explicit data alignment: objects can be explicitly aligned\n",
       "    to a set of labels, or the user can simply ignore the labels and let\n",
       "    `Series`, `DataFrame`, etc. automatically align the data for you in\n",
       "    computations.\n",
       "  - Powerful, flexible group by functionality to perform split-apply-combine\n",
       "    operations on data sets, for both aggregating and transforming data.\n",
       "  - Make it easy to convert ragged, differently-indexed data in other Python\n",
       "    and NumPy data structures into DataFrame objects.\n",
       "  - Intelligent label-based slicing, fancy indexing, and subsetting of large\n",
       "    data sets.\n",
       "  - Intuitive merging and joining data sets.\n",
       "  - Flexible reshaping and pivoting of data sets.\n",
       "  - Hierarchical labeling of axes (possible to have multiple labels per tick).\n",
       "  - Robust IO tools for loading data from flat files (CSV and delimited),\n",
       "    Excel files, databases, and saving/loading data from the ultrafast HDF5\n",
       "    format.\n",
       "  - Time series-specific functionality: date range generation and frequency\n",
       "    conversion, moving window statistics, moving window linear regressions,\n",
       "    date shifting and lagging, etc.\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pd?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python",
   "language": "python",
   "name": "conda-env-python-py"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
